package com.example.social.viewmodel

import android.content.Context
import android.net.Uri
import android.util.Log
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.social.api.ApiClient.threadApiService
import com.example.social.api.BaseResponse
import com.example.social.api.ThreadRequest
import com.example.social.utils.PostStatus
import kotlinx.coroutines.launch
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.MultipartBody
import okhttp3.RequestBody.Companion.toRequestBody
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
import java.io.FileNotFoundException
import java.io.InputStream
import java.util.UUID

class AddThreadViewModel : ViewModel() {
    private val _postStatus = MutableLiveData<PostStatus>()
    val postStatus: LiveData<PostStatus> get() = _postStatus

    init {
        _postStatus.value = PostStatus.Idle // 初始状态为未开始
    }

    // 发布话题
    fun submitThread(thread: String, userId: String, image: Uri?, context: Context) {
        _postStatus.value = PostStatus.Posting // 开始请求，设置为发布中状态

        if (image != null) {
            // 如果有图片，先上传图片
            uploadFileImage(image, context) { result ->
                if (result != null) {
                    // 图片上传成功后，保存数据
                    viewModelScope.launch {
                        saveData(thread, userId, result)
                    }
                } else {
                    // 图片上传失败，更新为发布失败
                    _postStatus.postValue(PostStatus.Complete(false))
                }
            }
        } else {
            viewModelScope.launch {
                saveData(thread, userId)
            }
        }
    }

// 保存数据方法
    private fun saveData(thread: String, userId: String, image: String? = null) {
        val request = ThreadRequest(thread = thread, image = image.orEmpty(), userId = userId)

        val call = threadApiService.add(request)
        call.enqueue(object : Callback<BaseResponse<String>> {
            override fun onResponse(
                call: Call<BaseResponse<String>>,
                response: Response<BaseResponse<String>>
            ) {
                if (response.isSuccessful) {
                    val body = response.body()
                    if (body != null && body.code == 0) {
                        // 请求成功且响应码为0，表示发布成功
                        _postStatus.postValue(PostStatus.Complete(true))
                    } else {
                        // 请求成功但响应码不为0，表示业务逻辑失败
                        Log.e("saveData", "业务错误: ${body?.msg}")
                        _postStatus.postValue(PostStatus.Complete(false))
                    }
                } else {
                    // 请求不成功，记录日志并更新状态
                    Log.e("saveData", "系统异常")
                    _postStatus.postValue(PostStatus.Complete(false))
                }
            }

            override fun onFailure(call: Call<BaseResponse<String>>, t: Throwable) {
                // 请求失败，记录日志并更新状态
                Log.e("saveData", "发布文章失败", t)
                _postStatus.postValue(PostStatus.Complete(false))
            }
        })
    }



    // 上传图片文件
    private fun uploadFileImage(imageUri: Uri?, context: Context, callback: (String?) -> Unit) {
        // 从 URI 获取输入流，如果失败则回调 null
        val inputStream = imageUri?.let { getInputStreamFromUri(it, context) } ?: return callback(null)
        Log.e("file picture:", imageUri.toString())

        // 获取图片的 MIME 类型
        val mimeType = context.contentResolver.getType(imageUri) ?: "image/jpeg" // 默认 MIME 类型为 image/jpeg

        // 根据 MIME 类型设置扩展名
        val fileExtension = when (mimeType) {
            "image/jpeg" -> "jpg"
            "image/png" -> "png"
            "image/gif" -> "gif"
            else -> "jpg" // 默认处理为 JPEG 类型
        }

        // 生成一个唯一的文件名，使用 UUID
        val uniqueFileName = "avatar_${UUID.randomUUID()}.$fileExtension"

        // 将输入流内容转换为请求体
        val requestBody = inputStream.readBytes().toRequestBody(mimeType.toMediaType())

        // 创建表单数据 MultipartBody.Part，使用唯一的文件名
        val body = MultipartBody.Part.createFormData("file", uniqueFileName, requestBody)

        // 调用 API 上传文件
        val call = threadApiService.uploadFile(body)

        call.enqueue(object : Callback<BaseResponse<String>> {
            // 上传成功的回调
            override fun onResponse(
                call: Call<BaseResponse<String>>,
                response: Response<BaseResponse<String>>
            ) {
                if (response.isSuccessful) {
                    // 如果响应成功，将数据传递给回调
                    callback(response.body()?.data)
                } else {
                    callback(null)
                    Log.e("uploadFileImage", "图片上传失败，响应代码: ${response.code()}")
                }
            }

            override fun onFailure(call: Call<BaseResponse<String>>, t: Throwable) {
                callback(null)
                Log.e("uploadFileImage", "图片上传请求失败", t)
            }
        })
    }

    // 从 URI 获取输入流
    private fun getInputStreamFromUri(uri: Uri, context: Context): InputStream? {
        return try {
            // 尝试通过内容解析器打开 URI 输入流
            context.contentResolver.openInputStream(uri)
        } catch (e: FileNotFoundException) {
            // 如果文件未找到，记录错误日志并返回 null
            Log.e("getInputStreamFromUri", "文件未找到: ${e.message}")
            null
        }
    }


    fun resetPostStatus() {
        _postStatus.value = PostStatus.Idle
    }
}